using UnityEngine;
using UnityEngine.UI;
using System.Collections;
using System.Collections.Generic;
using System.Text;

public class InputManager : MonoBehaviour
{
    public Text wordDisplay;        // 显示单词的文本组件
    public Text chineseDisplay;     // 显示中文提示的文本组件
    public Text phoneticsymbol_Display;  // 显示音标符号的文本组件
    
    [Header("反馈设置")]
    public GameObject feedbackCorrect;   // 正确答案的反馈UI
    public GameObject feedbackWrong;     // 错误答案的反馈UI
    public float feedbackDuration = 1.0f; // 反馈显示时间
    
    [Header("音效设置")]
    public AudioClip correctSound;       // 正确答案音效
    public AudioClip wrongSound;         // 错误答案音效
    private AudioSource audioSource;     // 音频源组件
    
    private Word currentWord;                   // 当前的单词
    private string currentInput = "";           // 当前的输入
    private bool isCompleted = false;           // 是否完成
    private float lastInputTime = 0f;
    private const float INPUT_DEBOUNCE_TIME = 0.05f; // 200毫秒防抖时间

    // 新增字段，用于跟踪缺失的字母
    private string missingLetters = "";         // 当前单词缺失的字母
    
    // 颜色设置
    [Header("颜色设置")]
    public Color[] segmentColors = new Color[] {
        new Color(1, 0.5f, 0.5f), // 浅红色
        new Color(0.5f, 1, 0.5f), // 浅绿色  
        new Color(0.5f, 0.5f, 1), // 浅蓝色
        new Color(1, 1, 0.5f),    // 浅黄色
        new Color(1, 0.5f, 1),    // 浅紫色
        new Color(0.5f, 1, 1)     // 浅青色
    };

    private void Start()
    {
        // 自动查找并分配Text组件
        if (wordDisplay == null || chineseDisplay == null)
        {
            FindAndAssignTextComponents();
        }
        
        // 初始化按钮事件
        InitializeButtonEvents();
        
        // 初始化音频源
        if (audioSource == null)
        {
            audioSource = gameObject.AddComponent<AudioSource>();
        }
        
        // 初始化反馈UI
        if (feedbackCorrect != null) feedbackCorrect.SetActive(false);
        if (feedbackWrong != null) feedbackWrong.SetActive(false);
        
        // 检查是否有音标分段问题
        CheckAndFixPhoneticParts();
            
        LoadNewWord();
    }

    private void Update()
    {
        // 键盘输入处理
        if (!isCompleted && Input.anyKeyDown)
        {
            foreach (char c in Input.inputString)
            {
                if (char.IsLetter(c))
                {
                    OnLetterButtonClick(c.ToString().ToLower());
                }
                else if (c == '\b') // 退格键
                {
                    OnBackspaceClick();
                }
            }
        }
    }

    // 加载新单词
    public void LoadNewWord()
    {
        if (WordDatabase.Instance == null)
        {
            Debug.LogError("无法加载单词：WordDatabase实例未找到");
            return;
        }
        
        // 重置状态
        currentInput = "";
        isCompleted = false;
        
        // 获取新单词
        currentWord = WordDatabase.Instance.GetRandomWord();
        
        // 计算缺失字母
        missingLetters = CalculateMissingLetters(currentWord.english, currentWord.incomplete);
        
        // 更新显示
        UpdateDisplay();
    }
    
    // 计算缺失的字母（用于答案验证）
    private string CalculateMissingLetters(string fullWord, string incompleteWord)
    {
        // 现在我们直接使用Word结构中的answer字段作为缺失的部分
        // 这个方法保留是为了兼容性，但实际上我们只需要返回currentWord.answer
        return currentWord.answer;
        
        /* 旧逻辑，现在不再使用
        string missing = "";
        
        if (string.IsNullOrEmpty(fullWord) || string.IsNullOrEmpty(incompleteWord) || 
            fullWord.Length != incompleteWord.Length)
            return "";
            
        for (int i = 0; i < fullWord.Length; i++)
        {
            if (incompleteWord[i] == '_')
            {
                missing += fullWord[i];
            }
        }
        
        return missing;
        */
    }

    // 更新显示
    private void UpdateDisplay()
    {   
        if (wordDisplay == null || currentWord.english == null)
        {
            return;
        }
        
        if (currentWord.parts == null || currentWord.parts.Count == 0)
        {
            // 如果没有分段信息，使用原始显示逻辑
            DisplayWithoutColorSegments();
            return;
        }
        
        // 使用分段颜色显示
        DisplayWithColorSegments();
        
        // 显示中文意思
        if (chineseDisplay != null)
        {
            chineseDisplay.text = currentWord.chinese;
        }
        
        // 显示音标，并应用分段颜色
        if (phoneticsymbol_Display != null && !string.IsNullOrEmpty(currentWord.phonetic))
        {
            DisplayPhoneticWithColors();
        }
    }
    
    // 使用分段颜色显示音标
    private void DisplayPhoneticWithColors()
    {
        if (phoneticsymbol_Display == null || string.IsNullOrEmpty(currentWord.phonetic))
        {
            return;
        }
        
        // 如果没有分段部分，直接显示
        if (currentWord.parts == null || currentWord.parts.Count == 0)
        {
            phoneticsymbol_Display.text = currentWord.phonetic;
            return;
        }
        
        List<string> phoneticParts = SplitPhoneticParts();
        
        // 用于调试
        Debug.Log($"显示音标分段: 单词 '{currentWord.english}', 音标 '{currentWord.phonetic}'");
        for (int i = 0; i < phoneticParts.Count; i++)
        {
            Debug.Log($"  段 {i}: 单词部分='{(i < currentWord.parts.Count ? currentWord.parts[i] : "无")}', 音标部分='{phoneticParts[i]}'");
        }
        
        StringBuilder sb = new StringBuilder();
        
        // 遍历每个音标部分，确保使用与单词部分相同的颜色索引
        for (int i = 0; i < phoneticParts.Count; i++)
        {
            // 跳过空的音标部分（不发音的字母）
            if (string.IsNullOrEmpty(phoneticParts[i]))
            {
                continue;
            }
            
            // 获取当前分段对应的颜色
            string colorHex = GetColorHexForIndex(i);
            
            // 添加带颜色的音标部分
            sb.Append("<color=");
            sb.Append(colorHex);
            sb.Append(">");
            sb.Append(phoneticParts[i] + " "); // 添加空格分隔
            sb.Append("</color>");
        }
        
        // 移除最后一个多余的空格（如果有）
        string result = sb.ToString().TrimEnd();
        
        // 设置音标显示文本
        phoneticsymbol_Display.text = result;
        
        // 调试输出
        Debug.Log($"音标显示: {result}");
    }
    
    // 使用分段颜色显示单词
    private void DisplayWithColorSegments()
    {
        StringBuilder sb = new StringBuilder();
        
        // 处理当前已有的输入
        bool hasInput = !string.IsNullOrEmpty(currentInput);
        string remainingInput = currentInput;
        
        // 创建一个字符数组表示不完整单词，用于检查哪些位置是下划线
        char[] incompleteChars = currentWord.incomplete.ToCharArray();
        
        // 跟踪当前输入已使用的字符数
        int inputUsed = 0;
        
        // 遍历每个分段
        for (int i = 0; i < currentWord.parts.Count; i++)
        {
            string part = currentWord.parts[i];
            string originalPart = part; // 保存原始部分
            
            // 获取当前分段对应的颜色
            string colorHex = GetColorHexForIndex(i);
            
            sb.Append("<color=");
            sb.Append(colorHex);
            sb.Append(">");
            
            // 查找这个部分在完整单词中的位置
            int partIndex = currentWord.english.IndexOf(part);
            if (partIndex < 0 || partIndex + part.Length > currentWord.english.Length)
            {
                // 找不到位置，直接显示
                sb.Append(part);
                sb.Append("</color>");
                continue;
            }
            
            // 检查这个部分中有没有需要隐藏的字符（下划线）
            bool hasUnderscores = false;
            for (int j = 0; j < part.Length; j++)
            {
                // 检查对应位置在incomplete中是否为下划线
                if (partIndex + j < incompleteChars.Length && incompleteChars[partIndex + j] == '_')
                {
                    hasUnderscores = true;
                    break;
                }
            }
            
            // 如果没有下划线，直接显示原始部分
            if (!hasUnderscores)
            {
                sb.Append(part);
                sb.Append("</color>");
                continue;
            }
            
            // 这是缺失部分，需要显示用户输入或下划线
            StringBuilder partDisplay = new StringBuilder();
            for (int j = 0; j < part.Length; j++)
            {
                if (partIndex + j < incompleteChars.Length)
                {
                    if (incompleteChars[partIndex + j] == '_')
                    {
                        // 这个位置需要用户输入
                        if (inputUsed < remainingInput.Length)
                        {
                            // 用户已经输入了这个位置
                            partDisplay.Append(remainingInput[inputUsed]);
                            inputUsed++;
                        }
                        else
                        {
                            // 用户还没输入到这个位置，显示下划线
                            partDisplay.Append('_');
                        }
                    }
                    else
                    {
                        // 这个位置不需要用户输入，直接显示原字符
                        partDisplay.Append(part[j]);
                    }
                }
            }
            
            sb.Append(partDisplay.ToString());
            sb.Append("</color>");
        }
        
        wordDisplay.text = sb.ToString();
        
        // 调试输出
        Debug.Log($"显示单词: {sb.ToString()}, 原始不完整单词: {currentWord.incomplete}, 输入: {currentInput}");
    }
    
    // 使用原始逻辑显示（无分段颜色）
    private void DisplayWithoutColorSegments()
    {
        if (wordDisplay != null)
        {
            wordDisplay.text = currentWord.incomplete;
            
            // 如果有输入，替换显示的下划线
            if (!string.IsNullOrEmpty(currentInput))
            {
                string displayText = currentWord.incomplete;
                
                // 找到第一个下划线序列的开始和结束位置
                int startUnderscoreIndex = -1;
                int endUnderscoreIndex = -1;
                
                for (int i = 0; i < displayText.Length; i++)
                {
                    if (displayText[i] == '_')
                    {
                        if (startUnderscoreIndex == -1)
                        {
                            startUnderscoreIndex = i;
                        }
                        endUnderscoreIndex = i;
                    }
                    else if (startUnderscoreIndex != -1)
                    {
                        // 找到了一段下划线序列，不需要继续寻找
                        break;
                    }
                }
                
                // 如果找到了下划线序列
                if (startUnderscoreIndex != -1)
                {
                    int underscoreCount = endUnderscoreIndex - startUnderscoreIndex + 1;
                    
                    // 构建新的显示文本
                    string newDisplayText = displayText.Substring(0, startUnderscoreIndex);
                    
                    // 添加用户输入（尽可能多地填充下划线）
                    for (int i = 0; i < underscoreCount; i++)
                    {
                        if (i < currentInput.Length)
                        {
                            newDisplayText += currentInput[i];
                        }
                        else
                        {
                            newDisplayText += '_';
                        }
                    }
                    
                    // 添加剩余部分
                    if (endUnderscoreIndex < displayText.Length - 1)
                    {
                        newDisplayText += displayText.Substring(endUnderscoreIndex + 1);
                    }
                    
                    displayText = newDisplayText;
                }
                
                wordDisplay.text = displayText;
            }
        }
    }
    
    // 分割音标为与单词分段相匹配的部分
    private List<string> SplitPhoneticParts()
    {
        // 如果没有音标或没有分段，返回空列表
        if (string.IsNullOrEmpty(currentWord.phonetic) || currentWord.parts == null || currentWord.parts.Count == 0)
        {
            Debug.LogWarning("无法分割音标：音标为空或单词没有分段");
            return new List<string>();
        }
        
        // 记录详细的调试信息
        Debug.Log($"开始分割音标: 单词='{currentWord.english}', 音标='{currentWord.phonetic}', 分段数量={currentWord.parts.Count}");
        
        // 如果已有预处理的音标分段，检查并使用
        if (currentWord.phoneticParts != null && currentWord.phoneticParts.Count > 0)
        {
            Debug.Log($"使用预处理的音标分段，数量={currentWord.phoneticParts.Count}");
            
            // 确保音标部分和单词部分数量一致
            if (currentWord.phoneticParts.Count == currentWord.parts.Count)
            {
                for (int i = 0; i < currentWord.phoneticParts.Count; i++)
                {
                    Debug.Log($"  分段 {i}: 单词='{currentWord.parts[i]}', 音标='{currentWord.phoneticParts[i]}'");
                }
                return new List<string>(currentWord.phoneticParts); // 返回副本而不是引用
            }
            else
            {
                Debug.LogWarning($"预处理的音标分段数量({currentWord.phoneticParts.Count})与单词分段数量({currentWord.parts.Count})不匹配，尝试重新分割");
            }
        }
        
        // 如果没有预处理的音标分段或数量不匹配，尝试从WordDatabase获取
        if (WordDatabase.Instance != null)
        {
            Debug.Log("尝试从WordDatabase获取音标分段");
            List<string> dbPhoneticParts = WordDatabase.Instance.GetPhoneticParts(currentWord);
            if (dbPhoneticParts.Count == currentWord.parts.Count)
            {
                Debug.Log($"从WordDatabase获取到的音标分段数量={dbPhoneticParts.Count}，与单词分段匹配");
                for (int i = 0; i < dbPhoneticParts.Count; i++)
                {
                    Debug.Log($"  分段 {i}: 单词='{currentWord.parts[i]}', 音标='{dbPhoneticParts[i]}'");
                }
                return dbPhoneticParts;
            }
            else
            {
                Debug.LogWarning($"WordDatabase返回的音标分段数量({dbPhoneticParts.Count})与单词分段数量({currentWord.parts.Count})不匹配");
            }
        }
        
        // 作为后备，尝试简单地按空格分割音标
        Debug.Log("尝试按空格分割音标");
        string[] phoneticPartsArray = currentWord.phonetic.Split(' ');
        List<string> phoneticParts = new List<string>(phoneticPartsArray);
        
        Debug.Log($"按空格分割后的音标部分数量={phoneticParts.Count}");
        
        // 确保音标部分和单词部分数量一致
        AdjustPhoneticPartsCount(ref phoneticParts);
        
        // 记录调整后的结果
        Debug.Log($"调整后的音标分段数量={phoneticParts.Count}");
        for (int i = 0; i < phoneticParts.Count; i++)
        {
            Debug.Log($"  最终分段 {i}: 单词='{currentWord.parts[i]}', 音标='{phoneticParts[i]}'");
        }
        
        return phoneticParts;
    }
    
    // 调整音标部分数量，确保与单词部分数量一致
    private void AdjustPhoneticPartsCount(ref List<string> phoneticParts)
    {
        // 如果音标部分比单词部分少，添加空字符串
        while (phoneticParts.Count < currentWord.parts.Count)
        {
            phoneticParts.Add("");
        }
        
        // 如果音标部分比单词部分多，尝试合并最后几个部分
        if (phoneticParts.Count > currentWord.parts.Count)
        {
            // 简单策略：保留前面的部分，丢弃多余的部分
            while (phoneticParts.Count > currentWord.parts.Count && phoneticParts.Count > 0)
            {
                phoneticParts.RemoveAt(phoneticParts.Count - 1);
            }
            
            Debug.LogWarning($"单词 '{currentWord.english}' 的音标部分数量调整为 {phoneticParts.Count} 以匹配单词分段");
        }
    }
    
    // 获取指定索引的颜色十六进制表示
    private string GetColorHexForIndex(int index)
    {
        if (segmentColors == null || segmentColors.Length == 0)
        {
            return "#000000"; // 默认黑色
        }
        
        // 循环使用颜色数组
        Color color = segmentColors[index % segmentColors.Length];
        
        // 转换为十六进制颜色代码
        return "#" + ColorUtility.ToHtmlStringRGB(color);
    }
    
    // 判断一个部分是否在不完整单词中是隐藏的（下划线）
    private bool IsPartHidden(string part, string incomplete)
    {
        if (string.IsNullOrEmpty(part) || string.IsNullOrEmpty(incomplete))
        {
            return false;
        }
        
        // 查找这个部分在完整单词中的位置
        int partIndex = currentWord.english.IndexOf(part);
        if (partIndex < 0 || partIndex + part.Length > incomplete.Length)
        {
            return false;
        }
        
        // 检查这个范围内是否有下划线
        for (int i = 0; i < part.Length; i++)
        {
            if (incomplete[partIndex + i] == '_')
            {
                return true; // 只要有一个下划线，就认为这个部分是隐藏的
            }
        }
        
        return false;
    }
    
    // 字母按钮点击处理
    public void OnLetterButtonClick(string letter)
    {
        // 防抖逻辑：避免短时间内重复输入
        if (Time.time - lastInputTime < INPUT_DEBOUNCE_TIME)
            return;
            
        lastInputTime = Time.time;
        
        // 已完成的单词不能再输入
        if (isCompleted)
            return;
            
        // 将输入追加到当前输入
        currentInput += letter;
        
        // 限制输入长度不超过缺失字母数量
        if (currentInput.Length > missingLetters.Length)
        {
            currentInput = currentInput.Substring(0, missingLetters.Length);
        }
        
        // 更新显示
        UpdateDisplay();
        
        // 如果输入长度等于缺失字母长度，自动检查答案
        if (currentInput.Length == missingLetters.Length)
        {
            CheckAnswer();
        }
    }
    
    // 退格键点击处理
    public void OnBackspaceClick()
    {
        // 防抖逻辑
        if (Time.time - lastInputTime < INPUT_DEBOUNCE_TIME)
            return;
            
        lastInputTime = Time.time;
        
        // 已完成的单词不能再编辑
        if (isCompleted)
            return;
            
        // 移除最后一个字符
        if (currentInput.Length > 0)
        {
            currentInput = currentInput.Substring(0, currentInput.Length - 1);
            UpdateDisplay();
        }
    }
    
    // 查找并分配Text组件
    private void FindAndAssignTextComponents()
    {
        // 尝试查找单词显示组件
        if (wordDisplay == null)
        {
            Text[] texts = FindObjectsOfType<Text>();
            foreach (Text text in texts)
            {
                string nameLower = text.name.ToLower();
                if (nameLower.Contains("word") || nameLower.Contains("english") || 
                    nameLower.Contains("单词") || nameLower.Contains("英文"))
                {
                    wordDisplay = text;
                    break;
                }
            }
        }
        
        // 尝试查找中文提示组件
        if (chineseDisplay == null)
        {
            Text[] texts = FindObjectsOfType<Text>();
            foreach (Text text in texts)
            {
                string nameLower = text.name.ToLower();
                if (nameLower.Contains("chinese") || nameLower.Contains("hint") || 
                    nameLower.Contains("中文") || nameLower.Contains("提示"))
                {
                    chineseDisplay = text;
                    break;
                }
            }
        }
        
        // 尝试查找音标显示组件
        if (phoneticsymbol_Display == null)
        {
            Text[] texts = FindObjectsOfType<Text>();
            foreach (Text text in texts)
            {
                string nameLower = text.name.ToLower();
                if (nameLower.Contains("phonetic") || nameLower.Contains("symbol") || 
                    nameLower.Contains("音标") || nameLower.Contains("pronunciation"))
                {
                    phoneticsymbol_Display = text;
                    Debug.Log("找到音标显示组件: " + text.name);
                    break;
                }
            }
        }
    }
    
    // 初始化按钮事件
    private void InitializeButtonEvents()
    {
        // 查找所有字母按钮并添加点击事件
        Button[] buttons = FindObjectsOfType<Button>(true);
        foreach (Button button in buttons)
        {
            string buttonName = button.name.ToLower();
            
            // 字母按钮
            if (buttonName.Length == 1 && char.IsLetter(buttonName[0]))
            {
                string letter = buttonName;
                button.onClick.AddListener(() => OnLetterButtonClick(letter));
            }
            // 带字母标签的按钮
            else if (button.GetComponentInChildren<Text>() != null)
            {
                Text buttonText = button.GetComponentInChildren<Text>();
                if (buttonText.text.Length == 1 && char.IsLetter(buttonText.text[0]))
                {
                    string letter = buttonText.text.ToLower();
                    button.onClick.AddListener(() => OnLetterButtonClick(letter));
                }
            }
            // 退格按钮
            else if (buttonName.Contains("back") || buttonName.Contains("delete") || 
                     buttonName.Contains("退格") || buttonName.Contains("删除"))
            {
                button.onClick.AddListener(OnBackspaceClick);
            }
            // 提交按钮不再需要添加事件
        }
    }
    
    // 播放音效
    private void PlaySound(AudioClip clip)
    {
        if (clip != null && audioSource != null)
        {
            audioSource.clip = clip;
            audioSource.Play();
        }
    }
    
    // 显示反馈
    private IEnumerator ShowFeedbackAndLoadNext(GameObject feedback, float duration, bool loadNext)
    {
        if (feedback != null)
        {
            feedback.SetActive(true);
            yield return new WaitForSeconds(duration);
            feedback.SetActive(false);
            
            // 如果需要加载新单词
            if (loadNext)
            {
                LoadNewWord();
            }
        }
    }

    // 检查答案
    private void CheckAnswer()
    {
        // 检查输入是否完成和正确
        if (currentInput.Length > 0)
        {
            // 输入完成，检查是否正确
            if (currentInput.ToLower() == missingLetters.ToLower())
            {
                // 答案正确
                isCompleted = true;
                
                // 触发正确回答事件
                if (GameManager.instance != null)
                {
                    GameManager.instance.OnWordCorrect(currentWord.english);
                }
                
                // 正确音效
                if (correctSound != null)
                {
                    PlaySound(correctSound);
                }
                
                // 显示正确反馈
                if (feedbackCorrect != null)
                {
                    feedbackCorrect.SetActive(true);
                    
                    // 使用Invoke直接延迟加载新单词，确保执行
                    Invoke("HideCorrectFeedbackAndLoadNewWord", feedbackDuration);
                }
                else
                {
                    // 如果没有反馈UI，立即加载新单词
                    Invoke("LoadNewWord", 0.5f);
                }
            }
            else
            {
                // 答案错误
                isCompleted = true; // 标记为已完成，不再接受输入
                
                // 显示原始单词
                if (wordDisplay != null)
                {
                    wordDisplay.text = currentWord.english;
                }
                
                // 错误音效
                if (wrongSound != null)
                {
                    PlaySound(wrongSound);
                }
                
                // 显示错误反馈
                if (feedbackWrong != null)
                {
                    feedbackWrong.SetActive(true);
                    
                    // 使用Invoke直接延迟加载新单词，确保执行
                    Invoke("HideWrongFeedbackAndLoadNewWord", feedbackDuration);
                }
                else
                {
                    // 如果没有反馈UI，立即加载新单词
                    Invoke("LoadNewWord", 0.5f);
                }
            }
        }
    }

    // 隐藏正确反馈并加载新单词
    private void HideCorrectFeedbackAndLoadNewWord()
    {
        if (feedbackCorrect != null)
        {
            feedbackCorrect.SetActive(false);
        }
        LoadNewWord();
    }

    // 隐藏错误反馈并加载新单词
    private void HideWrongFeedbackAndLoadNewWord()
    {
        if (feedbackWrong != null)
        {
            feedbackWrong.SetActive(false);
        }
        LoadNewWord();
    }

    /// <summary>
    /// 检查是否有音标分段问题，并尝试修复
    /// </summary>
    private void CheckAndFixPhoneticParts()
    {
        if (WordDatabase.Instance == null)
        {
            Debug.LogError("无法检查音标分段：WordDatabase实例未找到");
            return;
        }
        
        Debug.Log("检查音标分段问题...");
        
        // 先尝试重新处理所有单词的音标分段
        WordDatabase.Instance.ReprocessAllPhoneticParts();
        
        // 再次检查分段问题
        int problemCount = 0;
        
        // 检查第一个单词
        Word testWord = WordDatabase.Instance.GetRandomWord();
        
        if (testWord.phoneticParts == null || testWord.phoneticParts.Count == 0)
        {
            problemCount++;
            Debug.LogError($"单词 '{testWord.english}' 没有音标分段");
        }
        else if (testWord.phoneticParts.Count != testWord.parts.Count)
        {
            problemCount++;
            Debug.LogError($"单词 '{testWord.english}' 的音标分段数量({testWord.phoneticParts.Count})与单词分段数量({testWord.parts.Count})不匹配");
        }
        else if (testWord.phoneticParts.Count > 0 && 
                 !string.IsNullOrEmpty(testWord.phonetic) && 
                 !string.IsNullOrEmpty(testWord.phoneticParts[0]) && 
                 testWord.phoneticParts[0].Length > testWord.parts[0].Length * 2)
        {
            // 可能所有音标都在第一个元素中
            problemCount++;
            Debug.LogError($"单词 '{testWord.english}' 的音标分段问题: 全部音标都在第一个元素中: '{testWord.phoneticParts[0]}'");
        }
        
        if (problemCount > 0)
        {
            Debug.LogError($"发现 {problemCount} 个音标分段问题，请检查数据导入和处理逻辑");
        }
        else
        {
            Debug.Log("音标分段检查通过");
        }
        
        // 输出测试单词的分段信息用于确认
        Debug.Log($"测试单词 '{testWord.english}' 的音标分段情况:");
        for (int i = 0; i < testWord.parts.Count; i++)
        {
            string part = testWord.parts[i];
            string phoneticPart = i < testWord.phoneticParts.Count ? testWord.phoneticParts[i] : "无";
            Debug.Log($"  段 {i}: 单词='{part}', 音标='{phoneticPart}'");
        }
    }
} 